Scheduling and Synchronization for Multi-core Real-time Systems

Multi-core processors are already prevalent in general-purpose computing systems with manufacturers currently offering up to a dozen cores per processor. Real-time and embedded systems adopting such processors gain increased computational capacity, improved parallelism, and higher performance per watt. However, using multi-core processors in real-time applications also introduces new challenges and opportunities for efficient scheduling and task synchronization. In this dissertation, we study this problem, characterize the design space, and develop an analytical and systems framework for multi-core real-time scheduling. Exploiting the co-located nature of processor cores, the general principle adopted in this thesis is to statically partition tasks among processor cores, co-allocate synchronizing tasks when possible, and introduce limited inter-core task migration and synchronization for improving system utilization as necessary. We model the multi-core real-time scheduling problem as a binpacking problem and develop an object splitting algorithm for scheduling tasks on multi-core processors. We develop Highest-Priority Task Splitting (HPTS) to schedule independent sequential tasks on multi-core processors. We then analyze the overheads of inter-core task synchronization and provide mechanisms to efficiently allocate synchronizing sequential tasks on multicores by co-locating such tasks. We then generalize this approach to provide early solutions for scheduling parallel real-time tasks using the fork-join model. Next, we develop mechanisms to use such techniques in mixed-criticality systems. Finally, we describe the distributed resource kernel framework, where we demonstrate the practical feasibility of our approach. The results of this dissertation contribute to a system that can efficiently utilize multi-core processors to predictably execute periodic tasks with well-defined deadlines and analytically guarantee such deadlines. We provide a utilization bound of 65% for independent sequential tasks, demonstrate up to 50% reduction in the required number of cores using synchronization-aware allocation, and prove a 3.42 resource augmentation bound for parallel real-time task scheduling.